namespace ext
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <definedin>src\core\EventManager-more.js</definedin>
	/// <definedin>src\core\EventManager-more.js</definedin>
	/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
	[ScriptName("EventManager")]
	[ScriptNamespace("Ext")]
	[Imported()]
	public partial class EventManager
	{
		
		#region Constructors
		/// <summary>Constructor</summary>
		internal EventManager()
		{
		}
		#endregion
		
		#region Methods
		/// <summary>
		/// Adds a listener to be notified when the browser window is resized and provides resize event buffering (100 milliseconds),
		/// passes new viewport width and height to handlers.
		/// </summary>
		/// <definedin>src\core\EventManager-more.js</definedin>
		/// <param name="fn">The handler function the window resize event invokes.</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the handler function executes. Defaults to the browser window.</param>
		/// <param name="options">Options object as passed to {@link Ext.Element#addListener}</param>
		[ScriptName("onWindowResize")]
		public void OnWindowResize(System.Delegate fn, object scope, bool options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds a listener to be notified when the user changes the active text size. Handler gets called with 2 params, the old size and the new size.</summary>
		/// <definedin>src\core\EventManager-more.js</definedin>
		/// <param name="fn">The function the event invokes.</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the handler function executes. Defaults to the browser window.</param>
		/// <param name="options">Options object as passed to {@link Ext.Element#addListener}</param>
		[ScriptName("onTextResize")]
		public void OnTextResize(System.Delegate fn, object scope, bool options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes the passed window resize listener.</summary>
		/// <definedin>src\core\EventManager-more.js</definedin>
		/// <param name="fn">The method the event invokes</param>
		/// <param name="scope">The scope of handler</param>
		[ScriptName("removeResizeListener")]
		public void RemoveResizeListener(System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if the control, meta, shift or alt key was pressed during this event.</summary>
		/// <definedin>src\core\EventManager-more.js</definedin>
		[ScriptName("hasModifier")]
		public bool HasModifier()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <returns>
		/// True if the document is in a &apos;complete&apos; state (or was determined to
		/// be true by other means). If false, the state is evaluated again until canceled.
		/// </returns>
		[ScriptName("functioncheckReadyState")]
		public bool FunctioncheckReadyState()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Appends an event handler to an element. The shorthand version {@link #on} is equivalent. Typically you will
		/// use {@link Ext.Element#addListener} directly on an Element in favor of calling this version.
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to.</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">
		/// The handler function the event invokes. This function is passed
		/// the following parameters:&lt;ul&gt;
		/// &lt;li&gt;evt : EventObject&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.EventObject EventObject} describing the event.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;t : Element&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.Element Element} which was the target of the event.
		/// Note that this may be filtered by using the &lt;tt&gt;delegate&lt;/tt&gt; option.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;o : Object&lt;div class=&quot;sub-desc&quot;&gt;The options object from the addListener call.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;
		/// </param>
		/// <param name="scope">The scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) in which the handler function is executed. &lt;b&gt;Defaults to the Element&lt;/b&gt;.</param>
		/// <param name="options">
		/// An object containing handler configuration properties.
		/// This may contain any of the following properties:&lt;ul&gt;
		/// &lt;li&gt;scope : Object&lt;div class=&quot;sub-desc&quot;&gt;The scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) in which the handler function is executed. &lt;b&gt;Defaults to the Element&lt;/b&gt;.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;delegate : String&lt;div class=&quot;sub-desc&quot;&gt;A simple selector to filter the target or look for a descendant of the target&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;stopEvent : Boolean&lt;div class=&quot;sub-desc&quot;&gt;True to stop the event. That is stop propagation, and prevent the default action.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;preventDefault : Boolean&lt;div class=&quot;sub-desc&quot;&gt;True to prevent the default action&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;stopPropagation : Boolean&lt;div class=&quot;sub-desc&quot;&gt;True to prevent event propagation&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;normalized : Boolean&lt;div class=&quot;sub-desc&quot;&gt;False to pass a browser event to the handler function instead of an Ext.EventObject&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;delay : Number&lt;div class=&quot;sub-desc&quot;&gt;The number of milliseconds to delay the invocation of the handler after te event fires.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;single : Boolean&lt;div class=&quot;sub-desc&quot;&gt;True to add a handler to handle just the next firing of the event, and then remove itself.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;buffer : Number&lt;div class=&quot;sub-desc&quot;&gt;Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
		/// by the specified number of milliseconds. If the event fires again within that time, the original
		/// handler is &lt;em&gt;not&lt;/em&gt; invoked, but the new handler is scheduled in its place.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;target : Element&lt;div class=&quot;sub-desc&quot;&gt;Only call the handler if the event was fired on the target Element, &lt;i&gt;not&lt;/i&gt; if the event was bubbled up from a child node.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;br&gt;
		/// &lt;p&gt;See {@link Ext.Element#addListener} for examples of how to use these options.&lt;/p&gt;
		/// </param>
		[ScriptName("addListener")]
		public void AddListener(string el, string eventName, System.Delegate handler, object scope, object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Appends an event handler to an element. The shorthand version {@link #on} is equivalent. Typically you will
		/// use {@link Ext.Element#addListener} directly on an Element in favor of calling this version.
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to.</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">
		/// The handler function the event invokes. This function is passed
		/// the following parameters:&lt;ul&gt;
		/// &lt;li&gt;evt : EventObject&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.EventObject EventObject} describing the event.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;t : Element&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.Element Element} which was the target of the event.
		/// Note that this may be filtered by using the &lt;tt&gt;delegate&lt;/tt&gt; option.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;o : Object&lt;div class=&quot;sub-desc&quot;&gt;The options object from the addListener call.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;
		/// </param>
		/// <param name="scope">The scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) in which the handler function is executed. &lt;b&gt;Defaults to the Element&lt;/b&gt;.</param>
		/// <param name="options">
		/// An object containing handler configuration properties.
		/// This may contain any of the following properties:&lt;ul&gt;
		/// &lt;li&gt;scope : Object&lt;div class=&quot;sub-desc&quot;&gt;The scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) in which the handler function is executed. &lt;b&gt;Defaults to the Element&lt;/b&gt;.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;delegate : String&lt;div class=&quot;sub-desc&quot;&gt;A simple selector to filter the target or look for a descendant of the target&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;stopEvent : Boolean&lt;div class=&quot;sub-desc&quot;&gt;True to stop the event. That is stop propagation, and prevent the default action.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;preventDefault : Boolean&lt;div class=&quot;sub-desc&quot;&gt;True to prevent the default action&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;stopPropagation : Boolean&lt;div class=&quot;sub-desc&quot;&gt;True to prevent event propagation&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;normalized : Boolean&lt;div class=&quot;sub-desc&quot;&gt;False to pass a browser event to the handler function instead of an Ext.EventObject&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;delay : Number&lt;div class=&quot;sub-desc&quot;&gt;The number of milliseconds to delay the invocation of the handler after te event fires.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;single : Boolean&lt;div class=&quot;sub-desc&quot;&gt;True to add a handler to handle just the next firing of the event, and then remove itself.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;buffer : Number&lt;div class=&quot;sub-desc&quot;&gt;Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
		/// by the specified number of milliseconds. If the event fires again within that time, the original
		/// handler is &lt;em&gt;not&lt;/em&gt; invoked, but the new handler is scheduled in its place.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;target : Element&lt;div class=&quot;sub-desc&quot;&gt;Only call the handler if the event was fired on the target Element, &lt;i&gt;not&lt;/i&gt; if the event was bubbled up from a child node.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;br&gt;
		/// &lt;p&gt;See {@link Ext.Element#addListener} for examples of how to use these options.&lt;/p&gt;
		/// </param>
		[ScriptName("addListener")]
		public void AddListener(System.Html.Element el, string eventName, System.Delegate handler, object scope, object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Appends an event handler to an element. The shorthand version {@link #on} is equivalent. Typically you will
		/// use {@link Ext.Element#addListener} directly on an Element in favor of calling this version.
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to.</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">
		/// The handler function the event invokes. This function is passed
		/// the following parameters:&lt;ul&gt;
		/// &lt;li&gt;evt : EventObject&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.EventObject EventObject} describing the event.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;t : Element&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.Element Element} which was the target of the event.
		/// Note that this may be filtered by using the &lt;tt&gt;delegate&lt;/tt&gt; option.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;o : Object&lt;div class=&quot;sub-desc&quot;&gt;The options object from the addListener call.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;
		/// </param>
		/// <param name="scope">The scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) in which the handler function is executed. &lt;b&gt;Defaults to the Element&lt;/b&gt;.</param>
		[ScriptName("addListener")]
		public void AddListener(string el, string eventName, System.Delegate handler, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Appends an event handler to an element. The shorthand version {@link #on} is equivalent. Typically you will
		/// use {@link Ext.Element#addListener} directly on an Element in favor of calling this version.
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to.</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">
		/// The handler function the event invokes. This function is passed
		/// the following parameters:&lt;ul&gt;
		/// &lt;li&gt;evt : EventObject&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.EventObject EventObject} describing the event.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;t : Element&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.Element Element} which was the target of the event.
		/// Note that this may be filtered by using the &lt;tt&gt;delegate&lt;/tt&gt; option.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;o : Object&lt;div class=&quot;sub-desc&quot;&gt;The options object from the addListener call.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;
		/// </param>
		/// <param name="scope">The scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) in which the handler function is executed. &lt;b&gt;Defaults to the Element&lt;/b&gt;.</param>
		[ScriptName("addListener")]
		public void AddListener(System.Html.Element el, string eventName, System.Delegate handler, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Appends an event handler to an element. The shorthand version {@link #on} is equivalent. Typically you will
		/// use {@link Ext.Element#addListener} directly on an Element in favor of calling this version.
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to.</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">
		/// The handler function the event invokes. This function is passed
		/// the following parameters:&lt;ul&gt;
		/// &lt;li&gt;evt : EventObject&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.EventObject EventObject} describing the event.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;t : Element&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.Element Element} which was the target of the event.
		/// Note that this may be filtered by using the &lt;tt&gt;delegate&lt;/tt&gt; option.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;o : Object&lt;div class=&quot;sub-desc&quot;&gt;The options object from the addListener call.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;
		/// </param>
		[ScriptName("addListener")]
		public void AddListener(string el, string eventName, System.Delegate handler)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Appends an event handler to an element. The shorthand version {@link #on} is equivalent. Typically you will
		/// use {@link Ext.Element#addListener} directly on an Element in favor of calling this version.
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to.</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">
		/// The handler function the event invokes. This function is passed
		/// the following parameters:&lt;ul&gt;
		/// &lt;li&gt;evt : EventObject&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.EventObject EventObject} describing the event.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;t : Element&lt;div class=&quot;sub-desc&quot;&gt;The {@link Ext.Element Element} which was the target of the event.
		/// Note that this may be filtered by using the &lt;tt&gt;delegate&lt;/tt&gt; option.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;o : Object&lt;div class=&quot;sub-desc&quot;&gt;The options object from the addListener call.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;
		/// </param>
		[ScriptName("addListener")]
		public void AddListener(System.Html.Element el, string eventName, System.Delegate handler)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Removes an event handler from an element. The shorthand version {@link #un} is equivalent. Typically
		/// you will use {@link Ext.Element#removeListener} directly on an Element in favor of calling this version.
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The id or html element from which to remove the listener.</param>
		/// <param name="eventName">The name of the event.</param>
		/// <param name="fn">The handler function to remove. &lt;b&gt;This must be a reference to the function passed into the {@link #addListener} call.&lt;/b&gt;</param>
		/// <param name="scope">
		/// If a scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) was specified when the listener was added,
		/// then this must refer to the same object.
		/// </param>
		[ScriptName("removeListener")]
		public void RemoveListener(string el, string eventName, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Removes an event handler from an element. The shorthand version {@link #un} is equivalent. Typically
		/// you will use {@link Ext.Element#removeListener} directly on an Element in favor of calling this version.
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The id or html element from which to remove the listener.</param>
		/// <param name="eventName">The name of the event.</param>
		/// <param name="fn">The handler function to remove. &lt;b&gt;This must be a reference to the function passed into the {@link #addListener} call.&lt;/b&gt;</param>
		/// <param name="scope">
		/// If a scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) was specified when the listener was added,
		/// then this must refer to the same object.
		/// </param>
		[ScriptName("removeListener")]
		public void RemoveListener(System.Html.Element el, string eventName, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Removes all event handers from an element. Typically you will use {@link Ext.Element#removeAllListeners}
		/// directly on an Element in favor of calling this version.
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The id or html element from which to remove all event handlers.</param>
		[ScriptName("removeAll")]
		public void RemoveAll(string el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Removes all event handers from an element. Typically you will use {@link Ext.Element#removeAllListeners}
		/// directly on an Element in favor of calling this version.
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The id or html element from which to remove all event handlers.</param>
		[ScriptName("removeAll")]
		public void RemoveAll(System.Html.Element el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Adds a listener to be notified when the document is ready (before onload and before images are loaded). Can be
		/// accessed shorthanded as Ext.onReady().
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="fn">The method the event invokes.</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the handler function executes. Defaults to the browser window.</param>
		/// <param name="options">
		/// Options object as passed to {@link Ext.Element#addListener}. It is recommended that the options
		/// <c>{single: true}</c> be used so that the handler is removed on first invocation.
		/// </param>
		[ScriptName("onDocumentReady")]
		public void OnDocumentReady(System.Delegate fn, object scope, bool options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Adds a listener to be notified when the document is ready (before onload and before images are loaded). Can be
		/// accessed shorthanded as Ext.onReady().
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="fn">The method the event invokes.</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the handler function executes. Defaults to the browser window.</param>
		[ScriptName("onDocumentReady")]
		public void OnDocumentReady(System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Adds a listener to be notified when the document is ready (before onload and before images are loaded). Can be
		/// accessed shorthanded as Ext.onReady().
		/// </summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="fn">The method the event invokes.</param>
		[ScriptName("onDocumentReady")]
		public void OnDocumentReady(System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to an element. Shorthand for {@link #addListener}.</summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">The handler function the event invokes.</param>
		/// <param name="scope">(<c>this</c> reference) in which the handler function executes. &lt;b&gt;Defaults to the Element&lt;/b&gt;.</param>
		/// <param name="options">An object containing standard {@link #addListener} options</param>
		[ScriptName("on")]
		public static void On(string el, string eventName, System.Delegate handler, object scope, object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to an element. Shorthand for {@link #addListener}.</summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">The handler function the event invokes.</param>
		/// <param name="scope">(<c>this</c> reference) in which the handler function executes. &lt;b&gt;Defaults to the Element&lt;/b&gt;.</param>
		/// <param name="options">An object containing standard {@link #addListener} options</param>
		[ScriptName("on")]
		public static void On(System.Html.Element el, string eventName, System.Delegate handler, object scope, object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to an element. Shorthand for {@link #addListener}.</summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">The handler function the event invokes.</param>
		/// <param name="scope">(<c>this</c> reference) in which the handler function executes. &lt;b&gt;Defaults to the Element&lt;/b&gt;.</param>
		[ScriptName("on")]
		public static void On(string el, string eventName, System.Delegate handler, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to an element. Shorthand for {@link #addListener}.</summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">The handler function the event invokes.</param>
		/// <param name="scope">(<c>this</c> reference) in which the handler function executes. &lt;b&gt;Defaults to the Element&lt;/b&gt;.</param>
		[ScriptName("on")]
		public static void On(System.Html.Element el, string eventName, System.Delegate handler, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to an element. Shorthand for {@link #addListener}.</summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">The handler function the event invokes.</param>
		[ScriptName("on")]
		public static void On(string el, string eventName, System.Delegate handler)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Appends an event handler to an element. Shorthand for {@link #addListener}.</summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The html element or id to assign the event handler to</param>
		/// <param name="eventName">The name of the event to listen for.</param>
		/// <param name="handler">The handler function the event invokes.</param>
		[ScriptName("on")]
		public static void On(System.Html.Element el, string eventName, System.Delegate handler)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes an event handler from an element. Shorthand for {@link #removeListener}.</summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The id or html element from which to remove the listener.</param>
		/// <param name="eventName">The name of the event.</param>
		/// <param name="fn">The handler function to remove. &lt;b&gt;This must be a reference to the function passed into the {@link #on} call.&lt;/b&gt;</param>
		/// <param name="scope">
		/// If a scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) was specified when the listener was added,
		/// then this must refer to the same object.
		/// </param>
		[ScriptName("un")]
		public static void Un(string el, string eventName, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes an event handler from an element. Shorthand for {@link #removeListener}.</summary>
		/// <definedin>src\ext-core\src\core\EventManager.js</definedin>
		/// <param name="el">The id or html element from which to remove the listener.</param>
		/// <param name="eventName">The name of the event.</param>
		/// <param name="fn">The handler function to remove. &lt;b&gt;This must be a reference to the function passed into the {@link #on} call.&lt;/b&gt;</param>
		/// <param name="scope">
		/// If a scope (&lt;b&gt;<c>this</c>&lt;/b&gt; reference) was specified when the listener was added,
		/// then this must refer to the same object.
		/// </param>
		[ScriptName("un")]
		public static void Un(System.Html.Element el, string eventName, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
	}
}
